package com.ruoyi.common.core.result;


import com.ruoyi.common.core.enums.BaseEnum;
import com.ruoyi.common.core.enums.ResultEnum;
import com.ruoyi.common.core.pojo.result.PageInfo;
import com.ruoyi.common.core.pojo.result.Pages;
import com.ruoyi.common.core.pojo.vo.BaseVO;
import com.ruoyi.common.core.pojo.vo.MultiVO;
import com.ruoyi.common.core.pojo.vo.PageVO;
import com.ruoyi.common.core.pojo.vo.SingleVO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.util.Collection;

@Data
@Schema(description = "响应数据处理类")
public class Result {

    /**
     * 操作成功
     */
    public static BaseVO success() {
        return custom(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMessage());
    }

    /**
     * 操作成功
     *
     * @param message 提示信息
     */
    public static BaseVO success(String message) {
        return custom(ResultEnum.SUCCESS.getCode(), message);
    }

    /**
     * 操作失败
     */
    public static BaseVO fail() {
        return custom(ResultEnum.FAIL.getCode(), ResultEnum.FAIL.getMessage());
    }

    /**
     * 操作失败
     *
     * @param message 提示信息
     */
    public static BaseVO fail(String message) {
        return custom(ResultEnum.FAIL.getCode(), message);
    }

    /**
     * 成功或失败
     *
     * @param res boolean
     */
    public static BaseVO successOrFail(boolean res) {
        return successOrFail(res, success().getMessage(), fail().getMessage());
    }

    /**
     * 成功或失败
     *
     * @param res int
     */
    public static BaseVO successOrFail(int res) {
        return successOrFail(res > 0, success().getMessage(), fail().getMessage());
    }

    /**
     * 成功或失败
     *
     * @param res            int
     * @param successMessage 成功提示语
     * @param failMessage    失败提示语
     */
    public static BaseVO successOrFail(int res, String successMessage, String failMessage) {
        return successOrFail(res > 0, successMessage, failMessage);
    }

    /**
     * 成功或失败
     *
     * @param res            boolean
     * @param successMessage 成功提示语
     * @param failMessage    失败提示语
     */
    public static BaseVO successOrFail(boolean res, String successMessage, String failMessage) {
        if (res) return success(successMessage);
        return fail(failMessage);
    }

    /**
     * 自定义响应数据
     *
     * @param baseEnum 枚举
     */
    public static BaseVO custom(BaseEnum baseEnum) {
        return custom(baseEnum.getCode(), baseEnum.getMessage());
    }

    /**
     * 自定义响应数据
     *
     * @param code    状态码
     * @param message 提示信息
     */
    public static BaseVO custom(String code, String message) {
        BaseVO baseVO = new BaseVO();
        baseVO.setCode(code);
        baseVO.setMessage(message);
        return baseVO;
    }

    /**
     * 响应集合数据
     *
     * @param data 结果集
     * @param <T>  集合类型
     */
    public static <T> MultiVO<T> multi(Collection<T> data) {
        return multi(ResultEnum.SUCCESS.getMessage(), data);
    }

    /**
     * 响应集合数据
     *
     * @param message 提示信息
     * @param data    结果集
     * @param <T>     集合类型
     */
    public static <T> MultiVO<T> multi(String message, Collection<T> data) {
        return multi(ResultEnum.SUCCESS.getCode(), message, data);
    }

    /**
     * 响应集合数据
     *
     * @param baseEnum 枚举值
     * @param data     结果集
     * @param <T>      集合类型
     */
    public static <T> MultiVO<T> multi(BaseEnum baseEnum, Collection<T> data) {
        return multi(baseEnum.getCode(), baseEnum.getMessage(), data);
    }

    /**
     * 响应集合数据
     *
     * @param code    状态码
     * @param message 提示信息
     * @param data    结果集
     * @param <T>     集合类型
     */
    public static <T> MultiVO<T> multi(String code, String message, Collection<T> data) {
        MultiVO<T> tMultiVO = new MultiVO<>();
        tMultiVO.setCode(code);
        tMultiVO.setMessage(message);
        tMultiVO.setData(data);
        return tMultiVO;
    }

    /**
     * 响应单体数据
     *
     * @param data 结果
     * @param <T>  结果类型
     */
    public static <T> SingleVO<T> single(T data) {
        return single(ResultEnum.SUCCESS.getMessage(), data);
    }

    /**
     * 响应单体数据
     *
     * @param message 提示信息
     * @param data    结果
     * @param <T>     结果类型
     */
    public static <T> SingleVO<T> single(String message, T data) {
        return single(ResultEnum.SUCCESS.getCode(), message, data);
    }

    /**
     * 响应单体数据
     *
     * @param baseEnum 枚举值
     * @param data     结果
     * @param <T>      结果类型
     */
    public static <T> SingleVO<T> single(BaseEnum baseEnum, T data) {
        return single(baseEnum.getCode(), baseEnum.getMessage(), data);
    }

    /**
     * 响应单体数据
     *
     * @param code    状态码
     * @param message 提示信息
     * @param data    结果
     * @param <T>     结果类型
     */
    public static <T> SingleVO<T> single(String code, String message, T data) {
        SingleVO<T> tSingleVO = new SingleVO<>();
        tSingleVO.setCode(code);
        tSingleVO.setMessage(message);
        tSingleVO.setData(data);
        return tSingleVO;
    }

    /**
     * 响应分页数据
     *
     * @param pages 分页数据信息
     * @param <T>   数据类型
     */
    public static <T> PageVO<T> page(Pages<T> pages) {
        return page(ResultEnum.SUCCESS.getMessage(), pages);
    }

    /**
     * 响应分页数据
     *
     * @param pageInfo 分页信息
     * @param data     分页数据集
     * @param <T>      数据类型
     */
    public static <T> PageVO<T> page(PageInfo pageInfo, Collection<T> data) {
        return page(ResultEnum.SUCCESS.getMessage(), pageInfo, data);
    }

    /**
     * 响应分页数据
     *
     * @param message 提示信息
     * @param pages   分页数据信息
     * @param <T>     数据类型
     */
    public static <T> PageVO<T> page(String message, Pages<T> pages) {
        return page(ResultEnum.SUCCESS.getCode(), message, pages);
    }

    /**
     * 响应分页数据
     *
     * @param message  提示信息
     * @param pageInfo 分页信息
     * @param data     分页数据集
     * @param <T>      数据类型
     */
    public static <T> PageVO<T> page(String message, PageInfo pageInfo, Collection<T> data) {
        return page(ResultEnum.SUCCESS.getCode(), message, pageInfo, data);
    }

    /**
     * 响应分页数据
     *
     * @param baseEnum 枚举值
     * @param pages    分页数据信息
     * @param <T>      数据类型
     */
    public static <T> PageVO<T> page(BaseEnum baseEnum, Pages<T> pages) {
        return page(baseEnum.getCode(), baseEnum.getMessage(), pages);
    }


    /**
     * 响应分页数据
     *
     * @param baseEnum 枚举值
     * @param pageInfo 分页信息
     * @param data     分页数据集
     * @param <T>      数据类型
     */
    public static <T> PageVO<T> page(BaseEnum baseEnum, PageInfo pageInfo, Collection<T> data) {
        return page(baseEnum.getCode(), baseEnum.getMessage(), pageInfo, data);
    }

    /**
     * 响应分页数据
     *
     * @param code    状态码
     * @param message 提示信息
     * @param pages   分页数据信息
     * @param <T>     数据类型
     */
    public static <T> PageVO<T> page(String code, String message, Pages<T> pages) {
        PageInfo pageInfo = PageInfo.builder()
                .page(pages.getPage())
                .pages(pages.getPage())
                .size(pages.getSize())
                .total(pages.getTotal())
                .build();
        return page(code, message, pageInfo, pages.getData());
    }

    /**
     * 响应分页数据
     *
     * @param code     状态码
     * @param message  提示信息
     * @param pageInfo 分页信息
     * @param data     分页数据集
     * @param <T>      数据类型
     */
    public static <T> PageVO<T> page(String code, String message, PageInfo pageInfo, Collection<T> data) {
        PageVO<T> tPageVO = new PageVO<>();
        tPageVO.setCode(code);
        tPageVO.setMessage(message);
        tPageVO.setPageInfo(pageInfo);
        tPageVO.setData(data);
        return tPageVO;
    }
}
